package com.roger.homecenterscreen.ui.viewmodel

import android.content.Context
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.roger.homecenterscreen.data.model.ContentData
import com.roger.homecenterscreen.data.model.WeatherData
import com.roger.homecenterscreen.data.network.NetworkModule
import com.roger.homecenterscreen.data.repository.ContentRepository
import com.roger.homecenterscreen.data.repository.WeatherRepository
import com.roger.homecenterscreen.data.repository.CalendarRepository
import com.roger.homecenterscreen.data.repository.CalendarInfo
import com.roger.homecenterscreen.data.location.EnhancedLocationService
import com.roger.homecenterscreen.data.location.LocationData
import com.roger.homecenterscreen.utils.NetworkTimeService
import android.util.Log
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import kotlinx.coroutines.delay
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.ensureActive
import kotlinx.coroutines.isActive
import java.util.Calendar

class HomeViewModel(context: Context) : ViewModel() {
    
    companion object {
        private const val TAG = "HomeViewModel"
    }
    
    private val contentRepository = ContentRepository(NetworkModule.apiService)
    private val weatherRepository = WeatherRepository(NetworkModule.weatherApiService)
    private val calendarRepository = CalendarRepository(NetworkModule.calendarApiService, NetworkModule.lunarApiService)
    private val locationViewModel = LocationViewModel(context)
    private val enhancedLocationService = EnhancedLocationService(context)
    
    private val _contentData = MutableStateFlow<ContentData?>(null)
    val contentData: StateFlow<ContentData?> = _contentData.asStateFlow()
    
    private val _isLoading = MutableStateFlow(false)
    val isLoading: StateFlow<Boolean> = _isLoading.asStateFlow()
    
    private val _error = MutableStateFlow<String?>(null)
    val error: StateFlow<String?> = _error.asStateFlow()
    
    // 天气数据
    private val _weatherData = MutableStateFlow<WeatherData?>(null)
    val weatherData: StateFlow<WeatherData?> = _weatherData.asStateFlow()
    
    // 万年历数据
    private val _calendarData = MutableStateFlow<CalendarInfo?>(null)
    val calendarData: StateFlow<CalendarInfo?> = _calendarData.asStateFlow()
    
    // 时间同步状态
    private val _timeSyncStatus = MutableStateFlow<String?>(null)
    val timeSyncStatus: StateFlow<String?> = _timeSyncStatus.asStateFlow()
    
    // 位置相关
    val hasLocationPermission = locationViewModel.hasLocationPermission
    val isGettingLocation = locationViewModel.isGettingLocation
    val locationError = locationViewModel.locationError
    val locationData = locationViewModel.locationData
    
    init {
        Log.i(TAG, "🚀 HomeViewModel 初始化开始")
        
        // 最优先执行：初始化中国时区（不依赖网络）
        try {
            NetworkTimeService.initializeChinaTimeZone()
            Log.i(TAG, "✅ 中国时区初始化完成")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 时区初始化异常，但应用继续启动", e)
        }
        
        // 非阻塞执行时间同步（避免无网络时阻塞启动）
        performInitialTimeSyncNonBlocking()
        
        // 启动时执行一次完整初始化（网络操作都有异常处理）
        safeRefreshContent()
        safeRefreshCalendarData()
        
        // 设置固定位置：广东省佛山市南海区（包含网络异常处理）
        safeGetCurrentLocation()
        
        // 启动定时刷新任务
        startHourlyRefreshTask()
        
        Log.i(TAG, "✅ HomeViewModel 初始化完成")
    }
    
    fun setLocationPermission(granted: Boolean) {
        locationViewModel.setLocationPermission(granted)
    }
    
    fun refreshLocation() {
        try {
            locationViewModel.refreshLocation()
        } catch (e: Exception) {
            Log.e(TAG, "❌ 刷新位置异常", e)
            _error.value = "刷新位置失败: ${e.message}"
        }
    }
    
    fun getCurrentLocation() {
        viewModelScope.launch {
            try {
                Log.i(TAG, "🏠 使用固定位置: 广东省佛山市南海区")
                
                // 直接使用广东省佛山市南海区的位置信息
                val fixedLocation = LocationData(
                    latitude = 23.0268,   // 南海区纬度
                    longitude = 113.1617, // 南海区经度
                    city = "佛山市",
                    district = "南海区",
                    address = "广东省佛山市南海区"
                )
                
                // 更新LocationViewModel的数据用于UI显示
                locationViewModel.setLocationData(fixedLocation)
                
                // 直接设置WeatherRepository的位置数据
                weatherRepository.setLocationData(fixedLocation)
                refreshWeatherData()
                
                Log.i(TAG, "✅ 固定位置设置成功: ${fixedLocation.getDisplayName()}")
                
            } catch (e: Exception) {
                Log.e(TAG, "❌ 设置固定位置异常", e)
                _error.value = "位置设置异常: ${e.message}"
            }
        }
    }
    
    fun refreshContent() {
        viewModelScope.launch {
            _isLoading.value = true
            _error.value = null
            try {
                val result = contentRepository.getCustomContent()
                result
                    .onSuccess { data ->
                        _contentData.value = data
                    }
                    .onFailure { exception ->
                        Log.e(TAG, "❌ 内容获取失败", exception)
                        _error.value = exception.message ?: "获取内容失败"
                    }
            } catch (e: Exception) {
                Log.e(TAG, "❌ 内容刷新异常", e)
                _error.value = "获取内容失败: ${e.message ?: "未知错误"}"
            } finally {
                _isLoading.value = false
            }
        }
    }
    
    private fun refreshWeatherData() {
        viewModelScope.launch {
            Log.i(TAG, "🌤️ HomeViewModel: 开始刷新天气数据")
            try {
                weatherRepository.getWeatherData()
                    .onSuccess { data ->
                        Log.i(TAG, "✅ HomeViewModel: 天气数据获取成功")
                        Log.i(TAG, "   🏠 位置: ${data.location.getDisplayName()}")
                        Log.i(TAG, "   🌡️ 温度: ${data.currentWeather.temperature}°C")
                        Log.i(TAG, "   🌤️ 天气: ${data.currentWeather.weatherDesc}")
                        _weatherData.value = data
                    }
                    .onFailure { exception ->
                        Log.e(TAG, "❌ HomeViewModel: 天气数据获取失败", exception)
                        // 天气获取失败时不影响主界面，使用默认数据
                    }
            } catch (e: Exception) {
                Log.e(TAG, "❌ HomeViewModel: 刷新天气数据异常", e)
                // 异常同样不影响主界面
            } finally {
                Log.i(TAG, "🌤️ HomeViewModel: 天气数据刷新完成")
            }
        }
    }
    
    private fun refreshCalendarData() {
        viewModelScope.launch {
            Log.i(TAG, "📅 HomeViewModel: 开始获取万年历数据")
            try {
                calendarRepository.getTodayCalendarInfo()
                    .onSuccess { data ->
                        Log.i(TAG, "✅ HomeViewModel: 万年历数据获取成功")
                        Log.i(TAG, "   🗓️ 农历: ${data.lunarDate}")
                        Log.i(TAG, "   ✅ 宜: ${data.huangliInfo.suitable}")
                        Log.i(TAG, "   ❌ 忌: ${data.huangliInfo.unsuitable}")
                        _calendarData.value = data
                    }
                    .onFailure { exception ->
                        Log.e(TAG, "❌ HomeViewModel: 万年历数据获取失败", exception)
                        // 万年历获取失败时不影响主界面，使用默认数据
                    }
            } catch (e: Exception) {
                Log.e(TAG, "❌ HomeViewModel: 刷新万年历数据异常", e)
                // 异常同样不影响主界面
            } finally {
                Log.i(TAG, "📅 HomeViewModel: 万年历数据刷新完成")
            }
        }
    }
    
    fun clearError() {
        _error.value = null
        locationViewModel.clearLocationError()
    }
    
    fun getLocationDescription(): String {
        return locationViewModel.getLocationDescription()
    }
    
    /**
     * 执行初始时间同步（非阻塞式）- 避免无网络时阻塞启动
     */
    private fun performInitialTimeSyncNonBlocking() {
        viewModelScope.launch {
            try {
                Log.i(TAG, "🕐 应用启动：开始初始时间同步（非阻塞式）")
                _timeSyncStatus.value = "正在同步时间..."
                
                val result = NetworkTimeService.performTimeSync()
                
                if (result.isSuccess) {
                    _timeSyncStatus.value = "启动时间同步成功"
                    Log.i(TAG, "✅ 启动时间同步成功")
                } else {
                    val errorMsg = result.exceptionOrNull()?.message ?: "未知错误"
                    if (errorMsg.contains("网络不可用") || errorMsg.contains("网络连接")) {
                        _timeSyncStatus.value = "无网络，使用本地时间"
                        Log.w(TAG, "🌐 网络不可用，跳过时间同步")
                    } else {
                        _timeSyncStatus.value = "时间同步失败，使用本地时间"
                        Log.w(TAG, "⚠️ 启动时间同步失败: $errorMsg")
                    }
                }
            } catch (e: Exception) {
                _timeSyncStatus.value = "时间同步异常，使用本地时间"
                Log.e(TAG, "❌ 启动时间同步异常，但应用继续运行", e)
            }
        }
    }
    
    /**
     * 安全的内容刷新 - 包含网络异常处理
     */
    private fun safeRefreshContent() {
        viewModelScope.launch {
            try {
                refreshContent()
            } catch (e: Exception) {
                Log.e(TAG, "❌ 内容刷新异常，但应用继续运行", e)
                _error.value = "内容加载失败，但应用正常运行"
            }
        }
    }
    
    /**
     * 安全的日历数据刷新 - 包含网络异常处理
     */
    private fun safeRefreshCalendarData() {
        viewModelScope.launch {
            try {
                refreshCalendarData()
            } catch (e: Exception) {
                Log.e(TAG, "❌ 日历数据刷新异常，但应用继续运行", e)
            }
        }
    }
    
    /**
     * 安全的位置获取 - 包含网络异常处理
     */
    private fun safeGetCurrentLocation() {
        viewModelScope.launch {
            try {
                getCurrentLocation()
            } catch (e: Exception) {
                Log.e(TAG, "❌ 位置设置异常，但应用继续运行", e)
                _error.value = "位置设置失败，使用默认位置"
            }
        }
    }
    
    /**
     * 启动每小时刷新任务
     */
    private fun startHourlyRefreshTask() {
        viewModelScope.launch {
            Log.i(TAG, "⏰ 启动每小时定时刷新任务")
            
            while (isActive) { // 检查协程是否仍然活跃
                try {
                    // 计算到下一个整点的时间
                    val now = Calendar.getInstance()
                    val nextHour = Calendar.getInstance().apply {
                        set(Calendar.MINUTE, 0)
                        set(Calendar.SECOND, 0)
                        set(Calendar.MILLISECOND, 0)
                        add(Calendar.HOUR_OF_DAY, 1)
                    }
                    
                    val delayMillis = nextHour.timeInMillis - now.timeInMillis
                    Log.i(TAG, "⏰ 下次刷新将在 ${delayMillis / 1000 / 60} 分钟后 (${nextHour.time})")
                    
                    // 等待到下一个整点，使用 ensureActive() 检查取消状态
                    delay(delayMillis)
                    ensureActive() // 确保协程没有被取消
                    
                    // 执行每小时的刷新任务
                    performHourlyRefresh()
                    
                } catch (e: CancellationException) {
                    Log.i(TAG, "⏰ 定时刷新任务被取消（正常情况）")
                    break // 协程被取消，正常退出
                } catch (e: Exception) {
                    Log.e(TAG, "❌ 定时刷新任务异常", e)
                    // 出现异常时等待5分钟后重试
                    try {
                        delay(5 * 60 * 1000)
                        ensureActive()
                    } catch (ce: CancellationException) {
                        Log.i(TAG, "⏰ 重试等待期间协程被取消")
                        break
                    }
                }
            }
            Log.i(TAG, "⏰ 定时刷新任务已结束")
        }
    }
    
    /**
     * 执行每小时刷新
     */
    private suspend fun performHourlyRefresh() {
        try {
            val currentHour = Calendar.getInstance().get(Calendar.HOUR_OF_DAY)
            Log.i(TAG, "🔄 开始执行每小时刷新任务 (当前时间: ${currentHour}:00)")
            
            // 1. 时间同步 (如果需要)
            if (NetworkTimeService.shouldSyncTime()) {
                Log.i(TAG, "🕐 执行时间同步")
                val syncResult = NetworkTimeService.performTimeSync()
                if (syncResult.isSuccess) {
                    _timeSyncStatus.value = "时间同步成功 (${currentHour}:00)"
                } else {
                    _timeSyncStatus.value = "时间同步失败: ${syncResult.exceptionOrNull()?.message}"
                }
            }
            
            // 2. 刷新黄历信息
            Log.i(TAG, "📅 刷新黄历信息")
            refreshCalendarData()
            
            // 3. 刷新天气信息（使用固定的佛山南海区位置）
            Log.i(TAG, "🌤️ 刷新天气信息")
            refreshWeatherData()
            
            // 4. 刷新自定义内容
            Log.i(TAG, "📄 刷新自定义内容")
            refreshContent()
            
            Log.i(TAG, "✅ 每小时刷新任务完成 (${currentHour}:00)")
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 每小时刷新任务异常", e)
        }
    }
    
    /**
     * 手动触发刷新所有数据
     */
    fun refreshAllData() {
        viewModelScope.launch {
            Log.i(TAG, "🔄 手动触发刷新所有数据")
            try {
                performHourlyRefresh()
            } catch (e: Exception) {
                Log.e(TAG, "❌ 手动刷新所有数据异常", e)
                _error.value = "刷新失败: ${e.message}"
            }
        }
    }
    
    /**
     * 手动触发时间同步
     */
    fun manualTimeSync() {
        viewModelScope.launch {
            Log.i(TAG, "🕐 手动触发时间同步")
            _timeSyncStatus.value = "正在同步时间..."
            try {
                val result = NetworkTimeService.performTimeSync()
                if (result.isSuccess) {
                    _timeSyncStatus.value = "手动时间同步成功"
                } else {
                    _timeSyncStatus.value = "手动时间同步失败: ${result.exceptionOrNull()?.message}"
                }
            } catch (e: Exception) {
                Log.e(TAG, "❌ 手动时间同步异常", e)
                _timeSyncStatus.value = "手动时间同步异常: ${e.message}"
            }
        }
    }

} 